package com.qyx.pmpucat.util;

import com.qyx.pmpucat.entity.AQuestion;
import com.qyx.pmpucat.entity.AQuestionNum;
import com.qyx.pmpucat.entity.OptionCategory;
import com.qyx.pmpucat.entity.Question;
import com.qyx.pmpucat.mapper.AQuestionMapper;
import com.qyx.pmpucat.mapper.AQuestionNumMapper;
import com.qyx.pmpucat.mapper.OptionCategoryMapper;
import com.qyx.pmpucat.mapper.QuestionMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Component
@RequiredArgsConstructor
public class ImportTable {
    private final AQuestionMapper aQuestionMapper;
    private final AQuestionNumMapper aQuestionNumMapper;
    private final QuestionMapper questionMapper;
    private final OptionCategoryMapper optionCategoryMapper;

    /**
     * 执行数据转化，将AQuestion和AQuestionNum的数据导入到Question表中
     */
    @Transactional(rollbackFor = Exception.class)
    public void importData() {
        try {
            log.info("开始数据转化...");
            
            // 1. 查询所有AQuestion数据
            List<AQuestion> aQuestions = aQuestionMapper.selectAll();
            log.info("查询到 {} 条AQuestion数据", aQuestions.size());
            
            // 2. 查询所有AQuestionNum数据
            List<AQuestionNum> aQuestionNums = aQuestionNumMapper.selectAll();
            log.info("查询到 {} 条AQuestionNum数据", aQuestionNums.size());
            
            // 3. 将AQuestionNum按照id建立索引
            Map<Integer, AQuestionNum> questionNumMap = aQuestionNums.stream()
                    .collect(Collectors.toMap(AQuestionNum::getId, item -> item));
            
            // 4. 转换数据并保存
            int successCount = 0;
            for (AQuestion aQuestion : aQuestions) {
                try {
                    Question question = convertToQuestion(aQuestion, questionNumMap.get(aQuestion.getId()));
                    if (question != null) {
                        questionMapper.insert(question);
                        successCount++;
                    }
                } catch (Exception e) {
                    log.error("转换问题ID {} 时出错: {}", aQuestion.getId(), e.getMessage(), e);
                }
            }
            
            log.info("数据转化完成，成功转换 {} 条记录", successCount);
            
        } catch (Exception e) {
            log.error("数据转化过程中出错: {}", e.getMessage(), e);
            throw e;
        }
    }
    
    /**
     * 将AQuestion和AQuestionNum转换为Question对象
     */
    private Question convertToQuestion(AQuestion aQuestion, AQuestionNum aQuestionNum) {
        if (aQuestion == null) {
            return null;
        }
        
        Question question = new Question();
        
        // 设置基本信息
        question.setTitle(aQuestion.getQuestion());
        question.setType(aQuestion.getType() != null ? aQuestion.getType() : 1); // 默认单选题
        question.setSort(aQuestion.getId()); // 使用原ID作为排序
        question.setQuestionnaireId(1L); // 默认问卷ID，可根据需要调整
        
        // 设置区分度参数
        if (aQuestionNum != null) {
            question.setAlphj(aQuestionNum.getAlphj());
        }
        
        // 根据sort值设置optionCategoryId
        Long optionCategoryId = getOptionCategoryIdBySort(aQuestion.getId());
        question.setOptionCategoryId(optionCategoryId);
        
        // 转换选项
        List<Question.QuestionOption> options = convertOptions(aQuestion, aQuestionNum);
        question.setOptions(options);
        
        return question;
    }
    
    /**
     * 根据sort值获取对应的optionCategoryId
     */
    private Long getOptionCategoryIdBySort(Integer sort) {
        if (sort >= 1 && sort <= 16) {
            return 1L;
        } else if (sort >= 17 && sort <= 30) {
            return 2L;
        } else if (sort >= 31 && sort <= 55) {
            return 3L;
        } else if (sort >= 56 && sort <= 80) {
            return 2L;
        } else if (sort >= 81 && sort <= 89) {
            return 4L;
        } else {
            // 默认返回1
            return 1L;
        }
    }
    
    /**
     * 转换选项列表
     */
    private List<Question.QuestionOption> convertOptions(AQuestion aQuestion, AQuestionNum aQuestionNum) {
        List<Question.QuestionOption> options = new ArrayList<>();
        
        // 获取所有选项内容
        String[] optionContents = {
            aQuestion.getOptionA(),
            aQuestion.getOptionB(), 
            aQuestion.getOptionC(),
            aQuestion.getOptionD(),
            aQuestion.getOptionE(),
            aQuestion.getOptionF(),
            aQuestion.getOptionG()
        };
        
        // 获取betaj值数组（第一个选项的betaj为null，从betaj1开始对应第二个选项）
        Double[] betajValues = new Double[7];
        if (aQuestionNum != null) {
            betajValues[0] = null; // 第一个选项的betaj为null
            betajValues[1] = aQuestionNum.getBetaj1(); // 第二个选项
            betajValues[2] = aQuestionNum.getBetaj2(); // 第三个选项
            betajValues[3] = aQuestionNum.getBetaj3(); // 第四个选项
            betajValues[4] = aQuestionNum.getBetaj4(); // 第五个选项
            betajValues[5] = aQuestionNum.getBetaj5(); // 第六个选项
            betajValues[6] = aQuestionNum.getBetaj6(); // 第七个选项
        }
        
        // 构建选项列表
        long optionId = 1;
        for (int i = 0; i < optionContents.length; i++) {
            String content = optionContents[i];
            
            // 跳过空选项
            if (!StringUtils.hasText(content)) {
                continue;
            }
            
            Question.QuestionOption option = new Question.QuestionOption();
            option.setId(optionId++);
            option.setBetaj(betajValues[i]);
            option.setSort(i + 1);
            
            options.add(option);
        }
        
        return options;
    }
    
    /**
     * 创建或获取OptionCategory
     */
    private Long createOrGetOptionCategory(String content) {
        try {
            // 创建新的OptionCategory
            OptionCategory optionCategory = new OptionCategory();
            optionCategory.setDescription(content);
            optionCategory.setSort(1);
            
            // 创建选项列表
            List<OptionCategory.Option> options = new ArrayList<>();
            OptionCategory.Option option = new OptionCategory.Option();
            option.setId(1);
            option.setLabel(content);
            options.add(option);
            optionCategory.setOptions(options);
            
            // 设置创建人信息（使用默认值）
            optionCategory.setCreateBy(1L);
            optionCategory.setCreateUser("system");
            
            // 保存并返回ID
            optionCategoryMapper.insert(optionCategory);
            return optionCategory.getId();
            
        } catch (Exception e) {
            log.error("创建OptionCategory失败: {}", e.getMessage(), e);
            // 返回默认的分类ID
            return 1L;
        }
    }
    
    /**
     * 清空Question表数据（谨慎使用）
     */
    @Transactional(rollbackFor = Exception.class)
    public void clearQuestionData() {
        log.warn("正在清空Question表数据...");
        questionMapper.deleteByQuery(null);
        log.warn("Question表数据已清空");
    }
}
